COMMENT ⊗   VALID 00019 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00003 00002	
C00004 00003	1.0	INTRODUCTION TO GEOMES AND GEOMEL.
C00007 00004	Memory, Control, Input and Output Routines.
C00009 00005	1.0	A SIMPLE EXAMPLE.
C00013 00006	
C00015 00007	
C00033 00008	DATUM AND LINK ACCESSING.
C00040 00009	3.0	WINGED EDGE PRIMITIVES.
C00042 00010	4.0	EULER MAKE PRIMITIVES.
C00044 00011	5.0	EULER KILL PRIMITIVES.
C00045 00012	6.0	EASY POLYHEDRON ROUTINES.
C00046 00013	7.0	EUCLIDEAN TRANSFORMATIONS.
C00049 00014	8.0	GEOMETRIC MEASURE ROUTINES.
C00050 00015	9.0	BODY INTERSECTION AND CUTTING.
C00051 00016	10.0	IMAGE FORMATION ROUTINES.
C00052 00017	11.0	INPUT/OUTPUT ROUTINES.
C00053 00018	12.0	AUXILLARY ROUTINES: III DISPLAY AND ARITHMETIC.
C00054 00019	PART III
C00057 ENDMK
C⊗;

PART II - GEOMED AS A SAIL OR LISP ACCESSIBLE GRAPHICS COMMAND LANGUAGE.

	1.0	INTRODUCTION TO GEOMES AND GEOMEL.

	2.0	LINK AND DATUM ACCESSING.

	3.0	WINGED EDGE PRIMITIVES.

	4.0	EULER MAKE PRIMITIVES.

	5.0	EULER KILL PRIMITIVES.

	6.0	EASY POLYHEDRON ROUTINES.

	7.0	EUCLIDEAN TRANSFORMATIONS.

	8.0	GEOMETRIC MEASURE ROUTINES.

	9.0	BODY INTERSECTION AND CUTTING.

       10.0	IMAGE FORMATION ROUTINES.

       11.0	INPUT/OUTPUT ROUTINES.

       12.0	AUXILLARY ROUTINES: III DISPLAY AND ARITHMETIC.
1.0	INTRODUCTION TO GEOMES AND GEOMEL.

	GEOMED is implemented in PDP-10 machine  code and is composed
of  geometric modeling  subroutines. These  subroutines are  SAIL and
LISP accessible depending on how they are assembled and  loaded. When
assembled and load for SAIL, the GEOMED subroutines are called GEOMES
for  "Geometric  Modeling  Embedded  in  SAIL";  similarly  when  the
routines are assembled and loaded  for LISP, they are referred  to as
GEOMEL standing for "Geometric Modeling Embedded in LISP".

	Strictly  defined, I  would have  preferred to  use  the name
"GEOMED" only for the  editor itself and to  call the larger  project
"GEM" for Geometric Modeling; however this has  not caught on, and
so  the reader is warned  that there are two  objects named "GEOMED",
one being the  interactive drawing  program by that  name, the  other
being the larger geometric modeling project including GEOMEL, GEOMES,
the data structure, the language, and so on.

	As  a graphics  language,   GEOMED is  all semantics  with no
syntax of its own. There are about one hundred  subroutine which take
from one to four arguments, return one or no values, and usually have
considerible side effects on the GEOMED data structure.
Unless  otherwise  noted,   all  arguments  and   values  are
integers; subroutines  executed for effect return integer value zero.
Memory, Control, Input and Output Routines.

	GEOMED MKUNIV MKNODE KLNODE
	MKWORLD MKCAMERA MKWINDOW 
	OUTB3D OUTGEM OUTCAM OUTVID
	INB3D  INGEM  INCAM  INCRE

Datum and Link Names:

	XWC YWC ZWC AA BB CC  XPP YPP ZPP
	IX IY IZ  JX JY JZ  KX KY KZ  
	NFACE PFACE NED PED NVT PVT DAD SON BRO SIS  
	ALT ALT2 CW CCW CAR8 CDR8

Winged Edged Primitives:

	MKB MKF MKE MKV MKFRAME
	WING INVERT EVERT
	ECW ECCW OTHER VCW VCCW FCW FCCW
	BDET BATT BGET

Euler Routines:

	MKBFV MKEV ESPLIT MKFE GLUEE
	KLBFEV KLFE KLEV UNGLUE
	GLUE MKCOPY SWEEP ROTCOM PYRAMID FVDUAL
	MKCUBE MKCYLN MKBALL
	BIN BUN BSUB MKCVEX 
	MKBUCK ECUT FCUT BCUT

Euclidean Routines:

	TRANSL ROTATE SHRINK APTRAN INTRAN DISTANCE
	NORM MKROT1 ORTHO1 ORTHO2 DETERM ANGL3V 

Image Forming Routines:

	GEODPY IIIDPY SHOW1 SHOW2 SHOW3 SHOW4 
	TAKE1 TAKE2 OCCULT SHADOW CLIPER
	VPROJ UNPROJ FACOEF ECOEF

Arithmetic and Display Routines:

	PI SQRT LOG SIN COS ATAN ATAN2 ASIN ACOS
	DPYBUF DPYSST DPYSET DPYBIG DPYBRT 
	AVECT AIVECT RVECT RIVECT DPYOUT

1.0	A SIMPLE EXAMPLE.

	Study for a moment the sample  SAIL program, TEST1.SAI, shown
on the  next page.  In the program,   GEOMES is declared by requiring
the  source  file  GEOMES.HDR[GEM,HE];   GEM  stands  for   Geometric
Modeling; HE stands for Hand/Eye.  When executed,  TEST1 displays one
cubic brick tumbling around another.

	In GEOMES worlds,  windows, camera, bodies, faces,  edges and
vertices  are referred to  by integer pointers.  A world is  a set of
bodies; a camera is  a camera model; a  window ties pairs of  cameras
and worlds together;  and a body is a model  of a polyhedron composed
of faces,  edges and vertices. For this introduction, all bodies will
be rectangular right  prisms. To get the data structure  initialized,
write the following instruction:

	MKUNIV;
	BODY ← MKCUBE(XSIDE,YSIDE,ZSIDE);	make cubic solid.
	BODY ← MKCOPY(BODY);			make a copy.
	
	The  routine  MKCUBE generates a rectangular right prism with
sides of length XSIDE, YSIDE and ZSIDE. The center of  the  prism  is
initially  at  the  world  origin,  (0,0,0).   The arguments are real
numbers representing feet. The initial camera is located sixteen feet
above  the X-Y plane and is looking down with a 12.5 millimeter lens,
which means that any block with sides less than 20 feet  will  be  in
view.  The routine MKCOPY will return a copy of its argument, the new
body will have the same location and orientation as the old one,  and
must be moved before doing a hidden line elimination.

	WHOLE ← BATT(PART,WHOLE);	body attach.
	PART  ← BDET(PART);		body detach.

	The BATT routine attachs one body to  another  so  that  when
something  is  moved  or copied all its parts will be moved or copied
too. Naturally, parts may have subparts and so on. A  body  is  freed
from its role as a part of something by the BDET routine.

BEGIN "TEST1"
	DEFINE α="COMMENT";
	DEFINE π="3.1415927";
	REQUIRE "GEOMES.HDR[GEM,HE]" SOURCE_FILE;
	INTEGER B1,B2,F,E,V,V0,T;
	INTEGER WORLD,WINDOW,CAMERA;

α UNIVERSE CREATION;

	MKUNIV;
	
α BODY CREATION;
	
	B1 ← MKCUBE(4.0,1.0,2.0);      α MAKE RECTANGULAR PRISM;
	B2 ← MKCOPY(B1);	       α COPY THE PRISM;

α ACTION;

	FOR T←1 STEP 1 UNTIL 30 DO
		 OUTSTR(13&10);		α FLUSH THE PAGE PRINTER;
	TRANSLATE(B1,0,0,4);		α 4 FEET +Z TOWARDS CAMERA;
	ROTATE(B2,π/8,π/8,0);		α ROTATION ABOUT VECTOR;
	WHILE TRUE DO 
	BEGIN
		ROTATE(B1,0,-π/17,0);	α ROTATION CW ABOUT Y-AXIS;
	FOR T←1 STEP 1 UNTIL 40 DO
	BEGIN 
		ROTATE(B1,π/20,0,0);	α ROTATION CCW ABOUT X-AXIS;
		ROTATE(B2,0,π/16,0);	α ROTATION CCW ABOUT Y-AXIS;
		SHOW2(0,1);		α DISPLAY A SIMULATED IMAGE;
		IF INCHRS≥1 THEN DONE;	α EXIT ON TYPE-ANY-KEY;
	END;
	END;

END "TEST1"; BGB 19 MARCH 1973.

GEOMED;

	Passes control  to the geometric  editor,  GEOMED;  which has
its own arcane  jump table command scanner, display modes, I/O and so
on; see the first half of this document for further details. When the
exit command  "εE" is given, GEOMED  returns the address of  the node
which is at the top of its stack (or zero).

GEODPY;		...refreshs the "now" display of GEOMED.

SHOW1(WINDOW,GLASS);

	Display all the edges of all the objects of  the world of the
given window (or  the "now" window if the window  argument is 0). The
GLASS is  an integer  between 0  and '17;  GLASS corresponds  to  the
system's pieces of glass; use GLASS set to 1  if you do not know what
a  piece of glass  is. The command  SHOW1(0,1) is the  fastest way to
display the "now" world.

SHOW2(WINDOW,GLASS);

	Display all the visible edges of all the objects of the world
of the given window (or the "now" window if the window argument is 0).
SHOW2 calls the hidden line eliminator OCCULT.

SHOW3(WINDOW,GLASS);

	Display all the faces that are towards the camera. SHOW3 is about
as fast as SHOW1, but with the back sides of everything being hidden.

DATUM AND LINK ACCESSING.

	The GEOMED data  structure  is  implemented  as  twelve  word
blocks  containing pointers and data in the fashion usual to graphics
and simulation; an introduction to this technology can  be  found  in
Knuth.    The  language of implementation is PDP-10 machine code, and
although the data and subroutines discussed below are accessible from
SAIL,  with  the  exception of CORGET, no SAIL routines are called by
GEOMES routines. In particular, GEOMES emphatically has nothing to do
with LEAP.

	The  twelve  word  blocks of GEOMES are called "nodes". Nodes
are referred to by their actual machine  address  in  the  user  core
image, which is an integer called a "link". Thus the subroutines that
take nodes as arguments or return nodes as values pass  links  rather
than  the  nodes  themselves.   In  SAIL,  the user core image can be
accessed as a special array named MEMORY. Using the MEMORY feature of
SAIL,  the  GEOMES.HDR  defines  names  for  where links and data are
stored relative to the origin of a node.

3.0	WINGED EDGE PRIMITIVES.


3.1	MKB,MKF,MKE,MKV,MKFRAME.	Make BFEV Nodes.
3.2 	WING,INVERT,EVERT		Make and change wing pointers.
3.3	LINKED				Find if two entities are linked.
3.4	ECW,ECCW,			Edge fetching around FV perimeter.
3.5 	OTHER,VCW,VCCW,FCW,FCCW		Face-vertex fetching from an edge.
3.6	BDET,BATT,BGET			Body parts linking and body get.

INVERT(EDGE);

	An edge is a  directed vector with a positive  and a negative
vertex; INVERT flip the orientation of an edge vector and returns the
same edge.

EVERT(BODY);

	Evert turns  a  body inside  out,   or  vice  versa.   A  GEM
polyhedral  surface has  an  inside  and an  outside;  the inside  is
defined  by the orientation of the four  wing pointers in edge nodes;
the evert primitives changes the  order of these pointers in  all the
edges of the given body.

4.0	EULER MAKE PRIMITIVES.

4.1 	BNEW ← MKBFV;   	Make vertex polyhedron.
4.2 	VNEW ← MKEV(F,V);	MAKES NEW EDGE AND VERTEX SUCH THAT:
				VNEW = NVT(ENEW); V = PVT(ENEW);
	VNEW ← ESPLIT(E);	MAKES NEW EDGE AND VERTEX...
4.3 	ENEW ← MKFE(V1,F,V2);   MAKES NEW FACE AND EDGE SUCH THAT:
				FNEW = NFACE(ENEW); F = PFACE(ENEW);
				  V1 = PVT(ENEW);  V2 = NVT(ENEW).
4.4	ENEW ← GLUEE(F1,V1,F2,V2);	MAKES NEW EDGE, KILLS F2,
				AND MAKES A HOLE OR KILLS A BODY.
				  V1 = PVT(ENEW);  V2 = NVT(ENEW).

4.2	VNEW ← MKEV(FACE,VERTEX);
	VNEW ← ESPLIT(EDGE);

	Make a new  edge and a new vertex in  the given FACE from the
given VERTEX; the  new vertex is  return, VNEW; the  new edge can  be
accessed by taking PED(VNEW).
ESPLIT,	makes a new edge and a  new vertex, VNEW; the new edge may  be
obtained by taking PED(VNEW); the new  edge is place between VNEW and
PVT(EDGE).

4.3	ENEW ← MKFE(V1,FACE,V2);

	Make a new face and a new edge by  joining V1 and V2 of FACE.
The new  edge is returned, ENEW; the new  face may always be obtained
by taking NFACE(ENEW).
5.0	EULER KILL PRIMITIVES.

5.1 	QNEW ← KLBFEV(Q);	Kill entity.
5.2 	   F ← KLFE(E);		Kill E and NFACE(E), return PFACE(E).
5.3 	   E ← KLEV(V);		Kill V and PED(V), return other E of V.
	   V ← KLEV(E);		Kill E and NVT(E), retirn PVT(E).
5.4 	FNEW ← UNGLUE(E);	Undo an GLUEE.
6.0	EASY POLYHEDRON ROUTINES.

6.1	BODY ←	GLUE(FACE1,FACE2);	Glue face-face.
6.2	QNEW ←	MKCOPY(ENTITY);		Make copy.
6.3	FACE ←	SWEEP(FACE,FLAG);	Sweep cylinder.
6.4	FACE ←	ROTCOM(FACE);		Rotation completion.
6.5	PEAK ←	PYRAMID(FV);		Make pyramid on a face (or vertex).
6.6	BODY ←  FVDUAL(BODY);		Make face/vertex dual of a body.
6.7	BNEW ←  MKCUBE(DX,DY,DZ);	Make right rectangular prism.
6.8	BNEW ←  MKCYLN(RADIUS,N,DZ);	Make right cylinder.
6.9	BNEW ←  MKBALL(RADIUS,M,N);	Make sphere approximation.

7.0	EUCLIDEAN TRANSFORMATIONS.

FRAME ← TRANSLATE(INTEGER ENTITY; REAL DELTAX,DELTAY,DELTAZ);
FRAME ←    ROTATE(INTEGER ENTITY; REAL ABOUTX,ABOUTY,ABOUTZ);
FRAME ←    SHRINK(INTEGER ENTITY; REAL SCALEX,SCALEY,SCALEZ);

	When  the  ENTITY argument  is  non-zero,  these  subroutines
perform   the   indicated   Euclidean  Transformation:   translation,
rotation, dilation and reflection. When the ENTITY argument  is ZERO,
then  a  FRAME  node   representing  the  desired  transformation  is
returned.

FRAMES and EUCLIDEAN TRANSFORMATIONS

	A frame  node  has two  intrepretations: it  may  be used  to
represent  a  frame of  reference  or it  may  be used  to  specify a
Euclidean transformation.

	As a frame of reference the XWC,  YWC, ZWC datums contain the
location  of the origin  of the frame  in world  coordinates; and the
remaining nine datums IX,IY,IZ, JX,JY,JZ, KX,KY,KZ are the components
of three  unit vectors  I, J,   and K that  determine a  right handed
rectangular  Cartesian coordinate system. The  nine components of the
unit vectors form an orthonormal rotation matrix.

	As a Euclidean transformation, the frame is applied to the
3-D world coordinates of an entity Q to make new coordinates.
---------------------------------------------------------------------
|  APTRAN's inner most subroutine.				    |
|  Expects arguments in V and Q. Clobbers 1,2,X,Y,Z.		    |
|								    |
|	X ← XWC(V);						    |
|	Y ← YWC(V);						    |
|	Z ← ZWC(V);					            |
|						 		    |
|	XWC(V) ← X*IX(Q) + Y*JX(Q) + Z*KX(Q) + XWC(Q);		    |
|	YWC(V) ← X*IY(Q) + Y*JY(Q) + Z*KZ(Q) + YWC(Q);		    |
|	ZWC(V) ← X*IZ(Q) + Y*JZ(Q) + Z*KZ(Q) + ZWC(Q);		    |
---------------------------------------------------------------------

HOMOGENEOUS COORDINATES

	The interpretation of frame nodes can be given in the
four by four notation of homogeneous coordinates.
8.0	GEOMETRIC MEASURE ROUTINES.


9.0	BODY INTERSECTION AND CUTTING.


10.0	IMAGE FORMATION ROUTINES.


11.0	INPUT/OUTPUT ROUTINES.


12.0	AUXILLARY ROUTINES: III DISPLAY AND ARITHMETIC.
PART III

SYSTEMS PROGRAMMING NOTES:

	The GEOMES source files  are all found on the disk area [GEM,HE];
the file  Z.CMD is an RPG command file  such that the monitor command
"COMPILE @Z.CMD" will compile everything.

MAKING A GEOMEL

.R ILISP 50
---------------------------------------------------------------------
DESCRIPTION OF GEOMED MACHINE CODE.

	The over all program structure of GEOMED is determined by the
urge  to have approximately one  subroutine per page  of source code.
The subroutine  calling  conventions are  SAIL like;  accumulator  17
(named  "P") is used  as  a  push down  list  for  arguments and  return
addresses; a calling sequence goes: PUSH P,ARG↔ PUSH P,ARG↔ ... PUSHJ
P,SUBR and  a subroutine  return must  fix  up the  stack SUB  P,[XWD
N+1,N+1] and JRST @N+1(P).
	
	The somewhat unusal  appearance of GEOMED machine code arises
from the  use  of  FAIL  assembler macros  to  implement  ALGOL  like
subroutine notation and KNUTH like datum/link  notation; and from the
use of "double-arrow"  to place more than one machine instruction per
line and  the use  of  seven alternate  PDP-10 mnemonics.

	The seven alternate PDP-10 mnemonics are LAC, DAC, CAR, CDR,
DIP,   DAP and GO for  MOVE, MOVEM, HLRZ,  HRRZ,  HRLM, HRRM and JRST
respectively. The LAC,  DAC, DIP, DAP  come from PDP-1  nomensclature
and are shorter  and more pronoucible than  their PDP-10 equivalents.
The  CAR and CDR are from LISP which  got them from the IBM-709.  The
GO comes from  ALGOL and is shorter  and more descriptive than  JRST.
The  PDP-10 op  code names  sacrifice  pronoucibility  for systematic
nomensclature; and although I once proposed having alternate  concise
euphonious names  for the most  frequently used operations;  the idea
was  quite unpopular and so  I have abandoned it for  all except the 
above seven mnemonics.